package com.aviator.detective.common.util;

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Pattern;

/**
 * date工具类
 */
public class DateUtil {

        public static Long getCurrentUnixTime(){
            return Long.valueOf(System.currentTimeMillis()/1000L);
        }

        public static String parseStr(String str) {
            String sDate = "";
            SimpleDateFormat sdf1 = new SimpleDateFormat("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
            try {
                Date date = sdf1.parse (str);
                SimpleDateFormat sdf = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
                sDate = sdf.format (date);
                ////System.out.println(sDate);
            } catch (Exception e) {
                e.printStackTrace ( );
            }
            return sDate;
        }

        /**
         * 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss
         *
         * @param dateDate
         * @return
         */
        public static String dateToStrLong(java.util.Date dateDate) {
            SimpleDateFormat formatter = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
            String dateString = formatter.format (dateDate);
            return dateString;

        }

        /**
         * 将Date类型转换为字符串
         *
         * @param date 日期类型
         * @return 日期字符串
         */
        public static String format(Date date) {
            if (date == null) {
                return "";
            }
            return format (date, "yyyy-MM-dd HH:mm:ss");
        }

        public static String format(Calendar date) {
            if (date == null) {
                return "";
            }
            return format (date.getTime ( ), "yyyy-MM-dd HH:mm:ss");
        }

        /**
         * 将Date类型转换为字符串
         *
         * @param date    日期类型
         * @param pattern 字符串格式
         * @return 日期字符串
         */
        public static String format(Date date, String pattern) {
            if (date == null) {
                return "null";
            }
            if (pattern == null || pattern.equals ("") || pattern.equals ("null")) {
                pattern = "yyyy-MM-dd HH:mm:ss";
            }
            return new SimpleDateFormat (pattern).format (date);
        }

        /**
         * 将字符串转换为Date类型
         *
         * @param date 字符串类型
         * @return 日期类型
         */
        public static Date format(String date) {
            return format (date, null);
        }

        /**
         * 将字符串转换为Date类型
         * @param date    字符串类型
         * @param pattern 格式
         * @return 日期类型
         */
        public static Date format(String date, String pattern) {
            if (pattern == null || pattern.equals ("") || pattern.equals ("null")) {
                pattern = "yyyy-MM-dd HH:mm:ss";
            }
            if (date == null || date.equals ("") || date.equals ("null")) {
                return new Date ( );
            }
            Date d = null;
            try {
                d = new SimpleDateFormat (pattern).parse (date);
            } catch (ParseException pe) {
            }
            return d;
        }

        public static String getCurrDate() {
            return format (new Date ( ), "yyyy-MM-dd HH:mm:ss");
        }

        /**
         * 格局传入的日期 解析出 该用何种SimpleDateFormat
         *
         * @param dateStr
         * @return
         */
        public static SimpleDateFormat getSimpleDateFormatPattern(String dateStr) {
            SimpleDateFormat format = null;
            if (Pattern.matches ("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
                format = new SimpleDateFormat ("yyyy-MM-dd");
                ////System.out.println("用的yyyy-MM-dd");
            } else if (Pattern.matches ("\\d{4}\\d{2}\\d{2}", dateStr)) {
                format = new SimpleDateFormat ("yyyyMMdd");
            } else if (Pattern.matches ("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
                format = new SimpleDateFormat ("yyyy年MM月dd日", Locale.CHINA);
                // //System.out.println("用的yyyy年MM月dd日");
            } else if (Pattern.matches ("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
                format = new SimpleDateFormat ("yyyy年M月d日", Locale.CHINA);
            } else if (Pattern.matches ("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
                format = new SimpleDateFormat ("dMMMyyyy", Locale.ENGLISH);
            } else if (Pattern.matches ("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
                format = new SimpleDateFormat ("d-MMM-yyyy", Locale.ENGLISH);
            } else if (Pattern.matches ("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}", dateStr)) {
                format = new SimpleDateFormat ("yyyy-MM-dd HH:mm");
            } else if (dateStr.length ( ) > 20) {
                format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
            } else {
                format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
            }
            return format;
        }


        /**
         * 格局传入的日期 解析出 该用何种SimpleDateFormat
         *
         * @param dateStr
         * @return
         * @throws
         */
        public static Date parseDateByPattern(String dateStr) {
            SimpleDateFormat format = null;
            try {
                if (Pattern.matches ("\\d{4}-\\d{2}-\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy-MM-dd");
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}/\\d{2}/\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy/MM/dd");
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}\\d{2}\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyyMMdd");
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
                    format = new SimpleDateFormat ("yyyy年MM月dd日", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
                    format = new SimpleDateFormat ("yyyy年M月d日", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}/\\d{1,2}/\\d{1,2} \\d{2}:\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy/M/d HH:mm", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}\\.\\d{2}\\.\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy.MM.dd", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}年\\d{2}月", dateStr)) {
                    format = new SimpleDateFormat ("yyyy年MM月", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy-MM-dd HH:mm", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss.SSS", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss.SS", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{1}", dateStr)) {
                    format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss.S", Locale.CHINA);
                    return format.parse (dateStr);
                } else if (Pattern.matches ("\\d{2}:\\d{2}", dateStr)) {
                    format = new SimpleDateFormat ("HH:mm", Locale.CHINA);
                    return format.parse (dateStr);
                }
            } catch (Exception e) {

            }
            return null;
        }

        /**
         * 获取时间日期
         *
         * @param milliSeconds
         * @return
         */
        public static String getTimeMilisecondDesc(long milliSeconds) {
            long days = milliSeconds / (1000 * 60 * 60 * 24);
            milliSeconds = milliSeconds - (days * 24 * 60 * 60 * 1000);
            long hours = milliSeconds / (1000 * 60 * 60);
            milliSeconds = milliSeconds - (hours * 60 * 60 * 1000);
            long minutes = milliSeconds / (1000 * 60);
            milliSeconds = milliSeconds - (minutes * 60 * 1000);
            long seconds = milliSeconds / (1000);

            StringBuffer sb = new StringBuffer ( );
            if (days != 0) {
                sb.append (days + "天");
            }
            if (hours != 0) {
                sb.append (hours + "小时");
            }
            if (minutes != 0) {
                sb.append (minutes + "分钟");
            }
            if (seconds != 0) {
                sb.append (seconds + "秒");
            }
            return sb.toString ( );
        }

        /**
         * 取得当前日期所在周的第一天
         *
         * @param date
         * @return
         */
        public static Date getFirstDayOfWeek(Date date) {
            Calendar c = clearDate (date, 4);
            c.setFirstDayOfWeek (Calendar.MONDAY);
            c.set (Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek ( )); // Monday
            return c.getTime ( );
        }

        /**
         * 取得当前日期所在周的最后一天
         *
         * @param date
         * @return
         */
        public static Date getLastDayOfWeek(Date date) {
            Calendar c = clearDate (date, 4);
            c.setFirstDayOfWeek (Calendar.MONDAY);
            c.set (Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek ( ) + 6);
            c.set (Calendar.HOUR_OF_DAY, 23);
            c.set (Calendar.MINUTE, 59);
            c.set (Calendar.SECOND, 59);
            c.set (Calendar.MILLISECOND, 000);
            return c.getTime ( );
        }

        /**
         * 取得指定日期的当周的起始时间
         *
         * @param date
         * @return
         */
        public static Date[] getWeekLimit(Date date) throws Exception {
            Date date1 = getFirstDayOfWeek (date);
            Date date2 = getLastDayOfWeek (date);
            return new Date[]{date1, date2};
        }

        /**
         * 取得指定日期的当月起始时间
         *
         * @param date
         * @return
         */
        public static Date[] getMonthLimit(Date date) throws Exception {
            Calendar cal = clearDate (date, 5);
            cal.set (Calendar.DATE, 1);
            Date date1 = cal.getTime ( );

            cal.add (Calendar.MONTH, 1);
            cal.add (Calendar.SECOND, -1);
            Date date2 = cal.getTime ( );

            return new Date[]{date1, date2};
        }

        /**
         * 取得指定日期的当年起始时间
         *
         * @param date
         * @return
         */
        public static Date[] getYearLimit(Date date) throws Exception {
            Calendar cal = clearDate (date, 6);
            cal.set (Calendar.MONTH, 0);
            cal.set (Calendar.DATE, 1);
            Date date1 = cal.getTime ( );

            cal.add (Calendar.YEAR, 1);
            cal.add (Calendar.SECOND, -1);
            Date date2 = cal.getTime ( );

            return new Date[]{date1, date2};
        }

        /**
         * 取得指定日期当月的起始时间串
         *
         * @param date
         * @return
         */
        public static String[] getMonthLimitStr(Date date) throws Exception {
            Date[] rtDateArray = getMonthLimit (date);
            return new String[]{getDateTimeStr (rtDateArray[0]), getDateTimeStr (rtDateArray[1])};
        }

        /**
         * 取得指定日期当年的起始时间串
         *
         * @param date
         * @return
         */
        public static String[] getYearLimitStr(Date date) throws Exception {
            Date[] rtDateArray = getYearLimit (date);
            return new String[]{getDateTimeStr (rtDateArray[0]), getDateTimeStr (rtDateArray[1])};
        }

        /**
         * 取得后一天的时间字
         *
         * @param dateStr
         * @return
         */
        public static Date getDayAfter(String dateStr, int dayCnt) throws Exception {
            return getDayAfter (parseDate (dateStr), dayCnt);
        }

        /**
         * 取得后一天的时间
         *
         * @param date
         * @return
         */
        public static Date getDayAfter(Date date, int dayCnt) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.DATE, dayCnt);
            return cal.getTime ( );
        }

        /**
         * 设置前多少秒的时间
         *
         * @param date
         * @return
         */
        public static Date getSecondAfter(Date date, int secondCnt) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.SECOND, secondCnt);
            return cal.getTime ( );
        }


        /**
         * 取得后多少小时的时间
         *
         * @param date
         * @return
         */
        public static Date getDayHourAfter(Date date, int hourCnt) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.HOUR, hourCnt);
            return cal.getTime ( );
        }

        /**
         * 取得后多少月的时间
         *
         * @param date
         * @param monthCnt
         * @return
         */
        public static Date getMonthAfter(Date date, int monthCnt) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.MONTH, monthCnt);
            return cal.getTime ( );
        }

        /**
         * 取得前多少月的时间
         *
         * @param date
         * @param monthCnt
         * @return
         */
        public static Date getMonthbeteen(Date date, int monthCnt) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.MONTH, monthCnt);
            return cal.getTime ( );
        }

        /**
         * 取得后多少年的时间
         *
         * @param date
         * @return
         */
        public static Date getYearAfter(Date date, int yearCnt) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.YEAR, yearCnt);
            return cal.getTime ( );
        }


        /**
         * 取得后N天的时间的所有日期list
         *
         * @param date
         * @return
         */
        public static List<Date> getDayListAfter(Date date, int dayCnt) {
            List<Date> list = new ArrayList<Date> ( );
            GregorianCalendar cal = new GregorianCalendar ( );
            for (int i = 1; i <= dayCnt; i++) {
                cal.setTime (date);
                cal.add (Calendar.DATE, i);
                list.add (cal.getTime ( ));
            }
            return list;
        }

        /**
         * 取得指定天数差的时间
         *
         * @param dateStr
         * @return
         */
        public static Date getDayDiff(String dateStr, int dayCnt) throws Exception {
            return getDayDiff (parseDate (dateStr), dayCnt);
        }

        /**
         * 取得指定天数差的时间
         *
         * @param date
         * @return
         */
        public static Date getDayDiff(Date date, int dayCnt) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.DATE, dayCnt);
            return cal.getTime ( );
        }



        /**
         * 取得前今天0:00分时间
         * @return
         */
        public static Date getStartToday() {

            Calendar todayStart = Calendar.getInstance();
            todayStart.set(Calendar.HOUR_OF_DAY, 0);
            todayStart.set(Calendar.MINUTE, 0);
            todayStart.set(Calendar.SECOND, 0);
            todayStart.set(Calendar.MILLISECOND, 0);

            return todayStart.getTime();
        }

        /**
         * 取得前今天23:59:59秒分时间
         * @return
         */
        public static Date getEndToday() {
            Calendar todayEnd = Calendar.getInstance();
            todayEnd.set(Calendar.HOUR_OF_DAY, 23);
            todayEnd.set(Calendar.MINUTE, 59);
            todayEnd.set(Calendar.SECOND, 59);
            todayEnd.set(Calendar.MILLISECOND, 999);
            return todayEnd.getTime();
        }


        /**
         * 取得昨天的开始时间
         * @param date
         * @return
         */
        public static Date getStatusYestday(Date date) {

            Calendar tempStart = Calendar.getInstance();
            Date start = new Date();

            tempStart.setTime(start);
            tempStart.set(Calendar.HOUR_OF_DAY, 0);
            tempStart.set(Calendar.MINUTE, 0);
            tempStart.set(Calendar.SECOND, 0);
            tempStart.set(Calendar.MILLISECOND, 0);
            tempStart.add(Calendar.DAY_OF_YEAR, -1);
            Date time = tempStart.getTime();

            return time;
        }

        /**
         * 取得昨天的结束时间
         * @param date
         * @return
         */
        public static Date getEndYestday(Date date) {

            Calendar tempEnd = Calendar.getInstance();
            Date end = new Date();

            tempEnd.setTime(end);
            tempEnd.set(Calendar.HOUR_OF_DAY, 0);
            tempEnd.set(Calendar.MINUTE, 0);
            tempEnd.set(Calendar.SECOND, 0);
            tempEnd.set(Calendar.MILLISECOND, 0);
            tempEnd.add(Calendar.DAY_OF_YEAR, -1);

            tempEnd.set(Calendar.HOUR_OF_DAY, 23);// 小时
            tempEnd.set(Calendar.MINUTE, 59);// 分
            tempEnd.set(Calendar.SECOND, 59);// 秒
            tempEnd.set(Calendar.MILLISECOND, 0);// 秒
            Date time = tempEnd.getTime();
            return time;
        }



        /**
         * 取得前7天开始时间
         * @param date
         * @return
         */
        public static Date getStatus7Days(Date date) {

            Calendar tempEnd = Calendar.getInstance();
            Date end = new Date();

            tempEnd.setTime(end);
            tempEnd.set(Calendar.HOUR_OF_DAY, 0);
            tempEnd.set(Calendar.MINUTE, 0);
            tempEnd.set(Calendar.SECOND, 0);
            tempEnd.set(Calendar.MILLISECOND, 0);
            tempEnd.add(Calendar.DAY_OF_YEAR, -6);
            Date time = tempEnd.getTime();

            return time;

        }


        /**
         * 取得前7天结束时间
         * @param date
         * @return
         */
        public static Date getEnd7Days(Date date) {

            Calendar tempEnd = Calendar.getInstance();
            Date end = new Date();

            tempEnd.setTime(end);
            tempEnd.set(Calendar.HOUR_OF_DAY, 0);
            tempEnd.set(Calendar.MINUTE, 0);
            tempEnd.set(Calendar.SECOND, 0);
            tempEnd.set(Calendar.MILLISECOND, 0);
            tempEnd.add(Calendar.DAY_OF_YEAR, -6);

            tempEnd.set(Calendar.HOUR_OF_DAY, 138);// 小时
            tempEnd.set(Calendar.MINUTE, 354);// 分
            tempEnd.set(Calendar.SECOND, 359);// 秒
            tempEnd.set(Calendar.MILLISECOND, 0);//毫秒
            Date time = tempEnd.getTime();

            return time;

        }


        /**
         * 取得前30天的开始时间
         * @param date
         * @return
         */
        public static Date getStatus30Days(Date date) {
            Calendar tempEnd = Calendar.getInstance();
            Date end = new Date();

            tempEnd.setTime(end);
            tempEnd.set(Calendar.HOUR_OF_DAY, 0);
            tempEnd.set(Calendar.MINUTE, 0);
            tempEnd.set(Calendar.SECOND, 0);
            tempEnd.set(Calendar.MILLISECOND, 0);
            tempEnd.add(Calendar.DAY_OF_YEAR, -29);
            Date time = tempEnd.getTime();

            return time;
        }

        /**
         *  东8区时间
         * @param date
         * @return
         */
        public static Date getMongoDate(Date date) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Calendar ca = Calendar.getInstance();
            ca.setTime(date);
            ca.set(Calendar.HOUR_OF_DAY, 23);
            ca.set(Calendar.MINUTE, 59);
            ca.set(Calendar.SECOND, 59);
            ca.set(Calendar.MILLISECOND, 999);
            try {
                return sdf.parse(sdf.format(ca.getTime()));
            } catch (ParseException e) {

            }
            return new Date();
        }




        /**
         * 取得前一天的时间字符串
         *
         * @param dateStr
         * @return
         */
        public static String getYestdayStr(String dateStr) throws Exception {
            return getYestdayStr (parseDate (dateStr));
        }

        /**
         * 取得前一天的时间字符串
         *
         * @param date
         * @return
         */
        public static String getYestdayStr(Date date) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.DATE, -1);
            return getDateTimeStr (cal.getTime ( ));
        }


        /**
         * Date清零
         *
         * @param date
         * @param clearNum 1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
         * @return
         */
        public static Calendar clearDate(Date date, int clearNum) {
            Calendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            //毫秒
            if (clearNum > 0) {
                cal.set (Calendar.MILLISECOND, 0);
            }
            //秒

            if (clearNum > 1) {
                cal.set (Calendar.SECOND, 0);
            }
            //分钟
            if (clearNum > 2) {
                cal.set (Calendar.MINUTE, 0);
            }
            //小时
            if (clearNum > 3) {
                cal.set (Calendar.HOUR_OF_DAY, 0);
            }
            //天

            if (clearNum > 4) {
                cal.set (Calendar.DATE, 0);
            }
            //月份
            if (clearNum > 5) {
                cal.set (Calendar.MONTH, 0);
            }
            return cal;
        }


        /**
         * 把字符串转化为Date
         *
         * @param dateStr
         * @return
         */
        public static Date parseDate(String formatStr, String dateStr) throws ParseException {
            SimpleDateFormat format = new SimpleDateFormat (formatStr);
            return format.parse (dateStr);
        }

        public static Calendar parseCalendar(String formatStr, String dateStr) {
            Calendar c = Calendar.getInstance ( );
            try {
                c.setTime (parseDate (formatStr, dateStr));
            } catch (Exception e) {
                // TODO Auto-generated catch block
// e.printStackTrace();
                return null;
            }
            return c;
        }

        public static Calendar parseCalendar(String dateStr) {
            Calendar c = Calendar.getInstance ( );
            try {
                c.setTime (parseDateByPattern (dateStr));
            } catch (Exception e) {
                // TODO Auto-generated catch block
// e.printStackTrace();
                return null;
            }
            return c;
        }

        /**
         * 把字符串转化为Date
         *
         * @param dateStr
         * @return
         */
        public static Date parseDate(String dateStr) {
            if (dateStr == null || "".equals (dateStr)) {
                return null;
            }

            SimpleDateFormat format = null;
            if (Pattern.matches ("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
                format = new SimpleDateFormat ("yyyy-MM-dd");
            } else if (Pattern.matches ("\\d{4}\\d{2}\\d{2}", dateStr)) {
                format = new SimpleDateFormat ("yyyyMMdd");
            } else if (Pattern.matches ("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
                format = new SimpleDateFormat ("yyyy年MM月dd日", Locale.CHINA);
            } else if (Pattern.matches ("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
                format = new SimpleDateFormat ("yyyy年M月d日", Locale.CHINA);
            } else if (Pattern.matches ("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
                format = new SimpleDateFormat ("dMMMyyyy", Locale.ENGLISH);
            } else if (Pattern.matches ("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
                format = new SimpleDateFormat ("d-MMM-yyyy", Locale.ENGLISH);
            } else if (dateStr.length ( ) > 20) {
                format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss:SSS");
            } else {
                format = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
            }

            try {
                return format.parse (dateStr);
            } catch (ParseException e) {
                // TODO Auto-generated catch block
                e.printStackTrace ( );
            }
            return null;
        }


        /**
         * 取得的时间串，格式为 yyyy-MM-dd HH:mm:ss
         *
         * @return
         */
        public static String getDateTimeStr(Date date) {
            if (date == null) {
                return getCurDateTimeStr ( );
            }
            return new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss").format (date);
        }


        /**
         * 取得当前的时间，格式为 yyyy-MM-dd HH:mm:ss
         *
         * @return
         */
        public static String getCurDateTimeStr() {
            return new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss").format (new Date ( ));
        }


        /**
         * @param year
         * @return
         * @return计算一年的最大周
         * @author syl
         * @date 2014-1-11
         */
        public static int getMaxWeekOfYear(int year) {
            Calendar c = new GregorianCalendar ( );
            c.set (year, Calendar.DECEMBER, 31, 23, 59, 59);
            return getWeekOfYear (c.getTime ( ));
        }

        /**
         * 获取日期当前周
         *
         * @param date
         * @return
         */
        public static int getWeekOfYear(Date date) {
            Calendar c = new GregorianCalendar ( );
            c.setFirstDayOfWeek (Calendar.MONDAY);
            c.setMinimalDaysInFirstWeek (7);
            c.setTime (date);
            return c.get (Calendar.WEEK_OF_YEAR);
        }


        /**
         * 参数说明  返回一个Calendar数组，长度为2
         * 分别是开始日期和结束日期
         *
         * @param year    年分 例如 2014 i
         * @param weeknum 第几周 例如33
         * @return
         * @date 2014-1-11
         */
        public static Calendar[] getStartAndEndDate(int year, int weeknum) {

            Calendar cal = Calendar.getInstance ( );
            cal.set (Calendar.YEAR, year);
            cal.set (Calendar.WEEK_OF_YEAR, weeknum);
            int nw = cal.get (Calendar.DAY_OF_WEEK);
            Calendar start = (Calendar) cal.clone ( );
            Calendar end = (Calendar) cal.clone ( );
            start.add (Calendar.DATE, 1 - nw + 1);
            end.add (Calendar.DATE, 7 - nw + 1);
            Calendar[] darr = {start, end};
            return darr;
        }

        /**
         * 获取当期日期的一周 开始可结束日期 返回一个Calendar数组，长度为2  分别是开始日期和结束日期
         * @return
         */
        public static Calendar[] getCurrStartEndDate() {
            Calendar cal = Calendar.getInstance ( );
            // 向后推一天（从星期一到周末）
            cal.add (Calendar.DATE, -1);
            int nw = cal.get (Calendar.DAY_OF_WEEK);
            Calendar start = (Calendar) cal.clone ( );
            Calendar end = (Calendar) cal.clone ( );
            start.add (Calendar.DATE, 1 - nw + 1);
            end.add (Calendar.DATE, 7 - nw + 1);
            Calendar[] darr = {start, end};
            return darr;
        }

        /**
         * 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为7
         * @return
         */
        public static Calendar[] getCurrStartAndEndOfWeek() {
            Calendar cal = Calendar.getInstance ( );
            // 向后推一天（从星期一到周末）
            cal.add (Calendar.DATE, -1);
            int nw = cal.get (Calendar.DAY_OF_WEEK);
            Calendar start = (Calendar) cal.clone ( );
            start.add (Calendar.DATE, 1 - nw + 1);
            Calendar tuesday = (Calendar) cal.clone ( );//周二
            tuesday.add (Calendar.DATE, 2 - nw + 1);
            Calendar wednesday = (Calendar) cal.clone ( );//周三
            wednesday.add (Calendar.DATE, 3 - nw + 1);
            Calendar thursday = (Calendar) cal.clone ( );//周四
            thursday.add (Calendar.DATE, 4 - nw + 1);
            Calendar friday = (Calendar) cal.clone ( );//周五
            friday.add (Calendar.DATE, 5 - nw + 1);
            Calendar saturday = (Calendar) cal.clone ( );//周六
            saturday.add (Calendar.DATE, 6 - nw + 1);
            Calendar end = (Calendar) cal.clone ( );
            end.add (Calendar.DATE, 7 - nw + 1);
            Calendar[] darr = {start, tuesday, wednesday, thursday, friday, saturday, end};
            return darr;
        }


        /**
         * 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为
         * @return
         * @date 2014-1-11
         */
        public static Calendar[] getStartAndEndOfWeekByDate(Date date) {
            Calendar cal = Calendar.getInstance ( );
            cal.setTime (date);
            // 向后推一天（从星期一到周末）
            cal.add (Calendar.DATE, -1);
            int nw = cal.get (Calendar.DAY_OF_WEEK);
            Calendar start = (Calendar) cal.clone ( );
            start.add (Calendar.DATE, 1 - nw + 1);
            Calendar tuesday = (Calendar) cal.clone ( );//周二
            tuesday.add (Calendar.DATE, 2 - nw + 1);
            Calendar wednesday = (Calendar) cal.clone ( );//周三
            wednesday.add (Calendar.DATE, 3 - nw + 1);
            Calendar thursday = (Calendar) cal.clone ( );//周四
            thursday.add (Calendar.DATE, 4 - nw + 1);
            Calendar friday = (Calendar) cal.clone ( );//周五
            friday.add (Calendar.DATE, 5 - nw + 1);
            Calendar saturday = (Calendar) cal.clone ( );//周六
            saturday.add (Calendar.DATE, 6 - nw + 1);
            Calendar end = (Calendar) cal.clone ( );
            end.add (Calendar.DATE, 7 - nw + 1);
            Calendar[] darr = {start, tuesday, wednesday, thursday, friday, saturday, end};
            return darr;
        }

        /**
         * 算出俩个时间，所间隔的多少天
         * @param startDate
         * @param endDate
         * @return
         */
        public static Long getDaysBetween(Date startDate, Date endDate) {
            Calendar fromCalendar = Calendar.getInstance ( );
            fromCalendar.setTime (startDate);
            fromCalendar.set (Calendar.HOUR_OF_DAY, 0);
            fromCalendar.set (Calendar.MINUTE, 0);
            fromCalendar.set (Calendar.SECOND, 0);
            fromCalendar.set (Calendar.MILLISECOND, 0);

            Calendar toCalendar = Calendar.getInstance ( );
            toCalendar.setTime (endDate);
            toCalendar.set (Calendar.HOUR_OF_DAY, 0);
            toCalendar.set (Calendar.MINUTE, 0);
            toCalendar.set (Calendar.SECOND, 0);
            toCalendar.set (Calendar.MILLISECOND, 0);

            return (toCalendar.getTime ( ).getTime ( ) - fromCalendar.getTime ( ).getTime ( )) / (1000 * 60 * 60 * 24);
        }

        /**
         * 两个时间相差距离多少天多少小时多少分多少秒
         *
         * @param startDate 时间参数 1 格式：1990-01-01 12:00:00
         * @param endDate   时间参数 2 格式：2009-01-01 12:00:00
         * @return long[] 返回值为：{天, 时, 分, 秒}
         */
        public static long[] getDaysBetweenmm(String startDate, String endDate) {
            DateFormat df = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
            Date one;
            Date two;
            long day = 0;
            long hour = 0;
            long min = 0;
            long sec = 0;
            try {
                one = df.parse (startDate);
                two = df.parse (endDate);
                long time1 = one.getTime ( );
                long time2 = two.getTime ( );
                long diff;
                if (time1 < time2) {
                    diff = time2 - time1;
                } else {
                    diff = time1 - time2;
                }
                day = diff / (24 * 60 * 60 * 1000);
                hour = (diff / (60 * 60 * 1000) - day * 24);
                min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
                sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
            } catch (ParseException e) {
                e.printStackTrace ( );
            }
            long[] times = {day, hour, min, sec};
            return times;
        }

        /**
         * 根据指定的月字符串算出月初和月未的时间，精确到秒
         *
         * @param monthStr
         * @return
         */
        public static Date[] getDatetimeMonthLimit(String monthStr) {
            String start = monthStr + "-01 00:00:00";
            Date startTime = DateUtil.format (start);

            Calendar cal = Calendar.getInstance ( );
            cal.setTime (startTime);
            cal.set (Calendar.DATE, cal.getActualMaximum (Calendar.DATE));
            Date endTime = new Date (cal.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
            return new Date[]{startTime, endTime};
        }

        /**
         * 上月
         * 根据指定的月字符串算出月初和月未的时间，精确到秒
         *
         * @param monthStr
         * @return
         */
        public static Date[] getDatetimePreMonthLimit(String monthStr) {
            String start = monthStr + "-01 00:00:00";
            Date startTime = DateUtil.format (start);

            Calendar cal = Calendar.getInstance ( );
            cal.setTime (startTime);
            cal.add (Calendar.MONTH, -1);
            startTime = cal.getTime ( );

            cal.set (Calendar.DATE, cal.getActualMaximum (Calendar.DATE));
            Date endTime = new Date (cal.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
            return new Date[]{startTime, endTime};
        }

        /**
         * 根据指定的天字符串算出天开始和天结束的时间，精确到秒
         *
         * @return
         */
        public static Date[] getDatetimeDayLimit(String day) {
            String startStr = day + " 00:00:00";
            Date start = DateUtil.parseDate (startStr);
            return new Date[]{start, new Date (start.getTime ( ) + 24 * 60 * 60 * 1000l - 1l)};
        }

        /**
         * 前一天
         * 根据指定的天字符串算出天开始和天结束的时间，精确到秒
         *
         * @return
         */
        public static Date[] getDatetimePreDayLimit(String day) {
            String startStr = day + " 00:00:00";
            Date start = new Date (DateUtil.parseDate (startStr).getTime ( ) - 24 * 60 * 60 * 1000l);
            return new Date[]{start, new Date (start.getTime ( ) + 24 * 60 * 60 * 1000l - 1l)};
        }


        /**
         * 1 第一季度 2 第二季度 3 第三季度 4 第四季度
         *
         * @param date
         * @return
         */
        public static int getSeason(Date date) {

            int season = 0;

            Calendar c = Calendar.getInstance ( );
            c.setTime (date);
            int month = c.get (Calendar.MONTH);
            switch (month) {
                case Calendar.JANUARY:
                case Calendar.FEBRUARY:
                case Calendar.MARCH:
                    season = 1;
                    break;
                case Calendar.APRIL:
                case Calendar.MAY:
                case Calendar.JUNE:
                    season = 2;
                    break;
                case Calendar.JULY:
                case Calendar.AUGUST:
                case Calendar.SEPTEMBER:
                    season = 3;
                    break;
                case Calendar.OCTOBER:
                case Calendar.NOVEMBER:
                case Calendar.DECEMBER:
                    season = 4;
                    break;
                default:
                    break;
            }
            return season;
        }


        /**
         * 根据指定的季度 算出季度初和季度未的时间，精确到秒
         *
         * @param year    年份
         * @param nSeason 第几季度
         * @return
         */
        public static Date[] getDatetimeSeasonLimit(int year, int nSeason) {
            Calendar c = Calendar.getInstance ( );
            Date[] season = new Date[2];
            c.set (year, Calendar.JANUARY, 1, 0, 0, 0);
            c.set (Calendar.MILLISECOND, 0);
            if (nSeason == 1) {// 第一季度
                c.set (Calendar.MONTH, Calendar.JANUARY);
                season[0] = c.getTime ( );
                c.set (Calendar.MONTH, Calendar.MARCH);
                c.set (Calendar.DATE, c.getActualMaximum (Calendar.DATE));
                season[1] = new Date (c.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
            } else if (nSeason == 2) {// 第二季度
                c.set (Calendar.MONTH, Calendar.APRIL);
                season[0] = c.getTime ( );
                c.set (Calendar.MONTH, Calendar.JUNE);
                c.set (Calendar.DATE, c.getActualMaximum (Calendar.DATE));
                season[1] = new Date (c.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
            } else if (nSeason == 3) {// 第三季度
                c.set (Calendar.MONTH, Calendar.JULY);
                season[0] = c.getTime ( );
                c.set (Calendar.MONTH, Calendar.SEPTEMBER);
                c.set (Calendar.DATE, c.getActualMaximum (Calendar.DATE));
                season[1] = new Date (c.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
            } else if (nSeason == 4) {// 第四季度
                c.set (Calendar.MONTH, Calendar.OCTOBER);
                season[0] = c.getTime ( );
                c.set (Calendar.MONTH, Calendar.DECEMBER);
                c.set (Calendar.DATE, c.getActualMaximum (Calendar.DATE));
                season[1] = new Date (c.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
            }

            return season;
        }

        /**
         * 上一季度
         * 根据指定的季度 算出季度初和季度未的时间，精确到秒
         *
         * @param year    年份
         * @param nSeason 第几季度
         * @return
         */
        public static Date[] getDatetimePreSeasonLimit(int year, int nSeason) {
            if (nSeason == 1) {
                nSeason = 4;
                year = year - 1;
            } else {
                nSeason = nSeason - 1;
            }
            return getDatetimeSeasonLimit (year, nSeason);
        }

        /**
         * 根据指定的年算出年初和年未的时间，精确到秒
         *
         * @param year 年份
         * @return
         */
        public static Date[] getDatetimeYearLimit(int year) {
            Calendar c = Calendar.getInstance ( );
            Date[] res = new Date[2];
            c.set (Calendar.YEAR, year);
            c.set (Calendar.MONTH, Calendar.JANUARY);
            res[0] = c.getTime ( );
            c.set (Calendar.MONTH, Calendar.DECEMBER);
            c.set (Calendar.DATE, c.getActualMaximum (Calendar.DATE));
            res[1] = new Date (c.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
            return res;
        }

        /**
         * 去年
         * 根据指定的年算出年初和年未的时间，精确到秒
         *
         * @param year 年份
         * @return
         */
        public static Date[] getDatetimePreYearLimit(int year) {
            return getDatetimeYearLimit (year - 1);
        }

        /**
         * 获取加几天后的时间
         *
         * @param date
         * @param number 天数数量
         * @return
         */
        public static Date getNextDay(Date date, int number) {
            Calendar calendar = Calendar.getInstance ( );
            calendar.setTime (date);
            calendar.add (Calendar.DAY_OF_MONTH, +number);//+1今天的时间加一天
            date = calendar.getTime ( );
            return date;
        }

        /**
         * 计算俩个时间差多少天多少小时
         *
         * @param endDate
         * @param nowDate
         * @return
         */
        public static String getDatePoor(Date nowDate, Date endDate) {

            long nd = 1000 * 24 * 60 * 60l;
            long nh = 1000 * 60 * 60l;
            long nm = 1000 * 60l;
            // long ns = 1000;
            // 获得两个时间的毫秒时间差异
            long diff = endDate.getTime ( ) - nowDate.getTime ( );
            // 计算差多少天
            long day = diff / nd;
            // 计算差多少小时
            long hour = diff % nd / nh;
            // 计算差多少分钟
            long min = diff % nd % nh / nm;
            // 计算差多少秒//输出结果
            // long sec = diff % nd % nh % nm / ns;
            return day + "天" + hour + "小时";
        }


        /**
         * 计算俩个时间差多少天多少小时分钟
         *
         * @param endDate
         * @param nowDate
         * @return
         */
        public static String getDatePoor2(Date nowDate, Date endDate) {

            long nd = 1000 * 24 * 60 * 60l;
            long nh = 1000 * 60 * 60l;
            long nm = 1000 * 60l;
            // long ns = 1000;
            // 获得两个时间的毫秒时间差异
            long diff = endDate.getTime ( ) - nowDate.getTime ( );
            // 计算差多少天
            long day = diff / nd;
            // 计算差多少小时
            long hour = diff % nd / nh;
            // 计算差多少分钟
            long min = diff % nd % nh / nm;
            // 计算差多少秒//输出结果
            // long sec = diff % nd % nh % nm / ns;
            String tempStr = "";
            if (day > 0) {
                tempStr = day + "天";
            }
            if (hour > 0) {
                tempStr += hour + "小时";
            }
            if (min > 0) {
                tempStr += min + "分钟";
            }
            return tempStr;
        }

        /**
         * 计算俩个时间差多少分钟
         *
         * @param endDate
         * @param nowDate
         * @return
         */
        public static long getDatePoor3(Date nowDate, Date endDate) {
            long nm = 1000 * 60l;
            // long ns = 1000;
            // 获得两个时间的毫秒时间差异
            long diff = endDate.getTime ( ) - nowDate.getTime ( );
            Long tempLong = diff / nm;
            return tempLong;
        }

        public static String getTimes(String date) throws ParseException {
            String uu = "上午";
            if (Integer.valueOf (date.substring (0, 2)) > 12) {
                uu = "下午";
            }
            DateFormat dateFormat = new SimpleDateFormat ("hh:mm:ss");
            Date dates = null;
            dates = dateFormat.parse (date);
            date = dateFormat.format (dates);
            return uu + (date.substring (0, 5));
        }

        /**
         * 当前季度的开始时间
         *
         * @return
         */
        public static Date getCurrentQuarterStartTime() {
            Calendar c = Calendar.getInstance ( );
            int currentMonth = c.get (Calendar.MONTH) + 1;
            Date now = null;
            try {
                if (currentMonth >= 1 && currentMonth <= 3)
                    c.set (Calendar.MONTH, 1);
                else if (currentMonth >= 4 && currentMonth <= 6)
                    c.set (Calendar.MONTH, 3);
                else if (currentMonth >= 7 && currentMonth <= 9)
                    c.set (Calendar.MONTH, 4);
                else if (currentMonth >= 10 && currentMonth <= 12)
                    c.set (Calendar.MONTH, 9);
                c.set (Calendar.DATE, 1);
            } catch (Exception e) {
                e.printStackTrace ( );
            }
            return c.getTime ( );
        }

        /**
         * 当前季度的结束时间
         *
         * @return
         */
        public static Date getCurrentQuarterEndTime() {
            Calendar c = Calendar.getInstance ( );
            int currentMonth = c.get (Calendar.MONTH) + 1;
            try {
                if (currentMonth >= 1 && currentMonth <= 3) {
                    c.set (Calendar.MONTH, 2);
                    c.set (Calendar.DATE, 31);
                } else if (currentMonth >= 4 && currentMonth <= 6) {
                    c.set (Calendar.MONTH, 5);
                    c.set (Calendar.DATE, 30);
                } else if (currentMonth >= 7 && currentMonth <= 9) {
                    c.set (Calendar.MONTH, 8);
                    c.set (Calendar.DATE, 30);
                } else if (currentMonth >= 10 && currentMonth <= 12) {
                    c.set (Calendar.MONTH, 11);
                    c.set (Calendar.DATE, 31);
                }
            } catch (Exception e) {
                e.printStackTrace ( );
            }
            return c.getTime ( );
        }

        public static String getWeek(Date date) {
            String[] weeks = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
            Calendar cal = Calendar.getInstance ( );
            cal.setTime (date);
            int week_index = cal.get (Calendar.DAY_OF_WEEK) - 1;
            if (week_index < 0) {
                week_index = 0;
            }
            return weeks[week_index];
        }
        /**
         * 获取两个日期相隔天数  去掉时分秒，直接比对日
         *
         * @param fDate
         * @param oDate
         * @return
         */
        public static int getIntervalOfDays(Date fDate, Date oDate) {
            if (null == fDate || null == oDate) {
                return -1;
            }
            fDate = DateUtil.clearDate (fDate, 4).getTime ( );
            oDate = DateUtil.clearDate (oDate, 4).getTime ( );
            long intervalMilli = oDate.getTime ( ) - fDate.getTime ( );
            return (int) (intervalMilli / (24 * 60 * 60 * 1000));
        }

        public static String getStrTime(String cc_time) {
            BigDecimal bigDecimal = new BigDecimal (cc_time);
            System.out.print (" bigDecimal.longValue()" + bigDecimal.longValue ( ));
            String re_StrTime = null;
            SimpleDateFormat sdf = new SimpleDateFormat ("HH时mm分");
            long lcc_time = Long.valueOf (bigDecimal.longValue ( ));
            re_StrTime = sdf.format (new Date (lcc_time * 1000L));
            return re_StrTime;
        }

        public static int getMonth(Date date) {
            Calendar cal = Calendar.getInstance ( );
            cal.setTime (date);
            return cal.get (Calendar.MONTH) + 1;
        }

        public static int getYear(Date date) {
            Calendar now = Calendar.getInstance ( );
            now.setTime (date);
            return now.get (Calendar.YEAR);
        }

        public static Date getBeaferTime(Date date) {
            GregorianCalendar cal = new GregorianCalendar ( );
            cal.setTime (date);
            cal.add (Calendar.DATE, -1);
            return cal.getTime ( );
        }

        /*
         获取当前时间之前或之后几分钟 minute
         */
        public static String getTimeByMinute(Date date, int minute) {
            Calendar calendar = Calendar.getInstance ( );
            calendar.setTime (date);
            calendar.add (Calendar.MINUTE, minute);
            return new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss").format (calendar.getTime ( ));

        }

        /**
         * 接收日期格式字符转化为中文+日期格式
         * 刚刚（5分钟前）
         * 规则：①如果开课时间为当天的日期，显示“今天+时+分”
         * <p>
         * ②如果开课时间为昨天的日期，显示“昨天+时+分”
         * ③如果开课时间为前天的日期，显示“前天+时+分”
         * ④如果开课时间为明天的日期，显示“明天+时+分”
         * ⑤如果开课时间为后天的日期，显示“后天+时+分”
         * ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分”
         * ⑦其余日期均显示“月-日  时：分”
         * ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
         *
         * @param date
         * @return
         */
        public static String transFormationStringDate2(String date) {
            long[] daysBetweenmm = getDaysBetweenmm (date, format (new Date ( )));
            if (daysBetweenmm[0] == 0 && daysBetweenmm[1] == 0 && daysBetweenmm[2] < 6) {
                return "刚刚";
            }
            return transFormationStringDate (date);
        }


        public static String transFormationStringDate(String date) {
            Date now = new Date ( );
            SimpleDateFormat sss = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
            return transFormationStringDate (date, now, sss.format (now));

        }


        /**
         * 接收日期格式字符转化为中文+日期格式
         * 规则：①如果开课时间为当天的日期，显示“今天+时+分”
         * ②如果开课时间为昨天的日期，显示“昨天+时+分”
         * ③如果开课时间为前天的日期，显示“前天+时+分”
         * ④如果开课时间为明天的日期，显示“明天+时+分”
         * ⑤如果开课时间为后天的日期，显示“后天+时+分”
         * ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分”
         * ⑦其余日期均显示“月-日  时：分”
         * ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
         *
         * @param date
         * @return
         */
        public static String transFormationStringDate(String date, Date newDate, String newDateStr) {
            SimpleDateFormat sss = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
            try {
                String yyyyStr = date.substring (0, 4);
                String mmStr = date.substring (5, 7);
                String ddStr = date.substring (8, 10);

                String hhStr = date.substring (11, 13);
                String MMStr = date.substring (14, 16);
                String ssStr = date.substring (17, 19);

                int yyyy = Integer.parseInt (yyyyStr);
                int mm = Integer.parseInt (mmStr);
                int dd = Integer.parseInt (ddStr);

                int hh = Integer.parseInt (hhStr);
                int MM = Integer.parseInt (MMStr);
                int ss = Integer.parseInt (ssStr);


                int yyyy1 = Integer.parseInt (newDateStr.substring (0, 4));
                int mm1 = Integer.parseInt (newDateStr.substring (5, 7));
                int dd1 = Integer.parseInt (newDateStr.substring (8, 10));

                if (yyyy != yyyy1) {//如果开课时间不是当前年，显示“年-月-日 时：分”
                    return yyyyStr + "-" + mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
                }
                if (mm == mm1 && dd == dd1) {//如果开课时间为当天的日期，显示“今天+时+
                    return "今天" + " " + hhStr + ":" + MMStr;
                }
                Date allDate = sss.parse (date);
                Long daysBetween = getDaysBetween (newDate, allDate);
                if (daysBetween == -1) {//如果开课时间为昨天的日期，显示“昨天+时+分”
                    return "昨天" + " " + hhStr + ":" + MMStr;
                }
                if (daysBetween == -2) {//如果开课时间为前天的日期，显示“前天+时+分”
                    return "前天" + " " + hhStr + ":" + MMStr;
                }
                if (daysBetween == 1) {//如果开课时间为明天的日期，显示“明天+时+分”
                    return "明天" + " " + hhStr + ":" + MMStr;
                }
                if (daysBetween == 2) {//如果开课时间为后天的日期，显示“后天+时+分”
                    return "后天" + " " + hhStr + ":" + MMStr;
                }
                if (daysBetween > 2 || daysBetween < -2) {//如果开课时间超出后天
                    Date firstDayOfWeek1 = getFirstDayOfWeek (newDate);//当前日期所在周的第一天
                    Date firstDayOfWeek2 = getFirstDayOfWeek (allDate);//传入日期所在周的第一天
                    if (firstDayOfWeek1.getTime ( ) == firstDayOfWeek2.getTime ( )) {//并且还在当前周内，显示“本周X+时+分”
                        Long ad = getDaysBetween (firstDayOfWeek1, allDate);
                        switch (ad.intValue ( )) {
                            case 0:
                                return "本周一" + " " + hhStr + ":" + MMStr;
                            case 1:
                                return "本周二" + " " + hhStr + ":" + MMStr;
                            case 2:
                                return "本周三" + " " + hhStr + ":" + MMStr;
                            case 3:
                                return "本周四" + " " + hhStr + ":" + MMStr;
                            case 4:
                                return "本周五" + " " + hhStr + ":" + MMStr;
                            case 5:
                                return "本周六" + " " + hhStr + ":" + MMStr;
                            case 6:
                                return "本周日" + " " + hhStr + ":" + MMStr;
                        }
                    }
                }
                //其余日期均显示“月-日  时：分”
                return mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
                //format(allDate,"MM-dd HH:mm");
            } catch (Exception e) {
                return "日期格式字符转化错误";
            }
        }

        /**
         * 获取时间的各组成部分
         *
         * @param date
         * @return
         */
        public static int getYMDDate(Date date, String format) {
            SimpleDateFormat sdf = null;
            try {
                if (StringUtil.isEmpty (format)) {
                    if ("yyyy".equals (format)) {
                        sdf = new SimpleDateFormat ("yyyy");
                        String formatY = sdf.format (date);
                        return Integer.parseInt (formatY);
                    } else if ("MM".equals (format)) {
                        sdf = new SimpleDateFormat ("MM");
                        String formatY = sdf.format (date);
                        return Integer.parseInt (formatY);
                    } else if ("dd".equals (format)) {
                        sdf = new SimpleDateFormat ("dd");
                        String formatY = sdf.format (date);
                        return Integer.parseInt (formatY);
                    }

                }
                return 0;
            } catch (Exception e) {
                return 0;
            }
        }

        /**
         * 接受开播时间与结束时间 返回播放状态（）
         *
         * @param startTime
         * @param endTime
         * @return
         */
        public static String getStatusStr(String startTime, String endTime) {
            if (!StringUtil.isEmpty (endTime)) {
                return "0";
            }
            Date date = new Date ( );
            if (StringUtil.isEmpty (startTime)) {
                long time = format (startTime).getTime ( );
                if (time > date.getTime ( )) {
                    return "1";
                } else {
                    return "2";
                }
            }
            return "";
        }

        public static void main(String[] args) {

            String date = "2018-01-12 12:07:06";

            int yyyy = Integer.parseInt (date.substring (0, 4));
            int mm = Integer.parseInt (date.substring (5, 7));
            int dd = Integer.parseInt (date.substring (8, 10));

            int hh = Integer.parseInt (date.substring (11, 13));
            int MM = Integer.parseInt (date.substring (14, 16));
            int ss = Integer.parseInt (date.substring (17, 19));

            //System.out.println (yyyy);
            //System.out.println (mm);
            //System.out.println (dd);

            //System.out.println (hh);
            //System.out.println (MM);
            //System.out.println (ss);
        }


        /**
         * @describe: 获取当天的0点0分0秒的日期和23点59分59秒的日期
         * @returnType Date
         * @createTime 2018年4月28日下午6:21:28
         */
        public static Date getNeedTime(int hour,int minute,int second,int day){
            Calendar calendar = Calendar.getInstance();
            if(day != 0){
                calendar.add(Calendar.DATE,day);
            }
            calendar.set(Calendar.HOUR_OF_DAY,hour);
            calendar.set(Calendar.MINUTE,minute);
            calendar.set(Calendar.SECOND,second);

            return calendar.getTime();
        }
}
